package org.jeecg.modules.common.utils;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.poi.ss.formula.functions.T;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.common.api.IRow2ColTransfer;
import org.jeecg.modules.student.entity.StuStudent;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.*;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

import java.lang.reflect.Field;


public class BeanObjUtil {

    /**
     * 行转列函数
     *
     * @param objDataList 对象数据列表list
     * @param groupFields 固定分组列
     * @param colsFields  列名属性所在的属性：例如：科目字段（值是=语文 英语 数学）
     * @param valueFields 允许空，值属性所在的属性：例如：成绩字段（值是=98.5 99 59.5）
     * @return
     * @throws NoSuchFieldException
     * @throws IllegalAccessException
     */
    public static List<JSONObject> dataRow2ColData(List<Object> objDataList, String[] groupFields, String[] colsFields, String[] valueFields) throws NoSuchFieldException, IllegalAccessException {
        return dataRow2ColData(objDataList, groupFields, colsFields, valueFields, null, null, null);
    }

    /**
     * 行转列函数，拓展计算函数
     *
     * @param objDataList          对象数据列表list
     * @param groupFields          固定分组列
     * @param colsFields           列名属性所在的属性：例如：科目字段（值是=语文 英语 数学）
     * @param valueFields          允许空，值属性所在的属性：例如：成绩字段（值是=98.5 99 59.5）
     * @param groupCalculationFun  计算函数，支持[sum,count,max,min]不区分大小写
     * @param groupCalculationName 计算值列名字符串=列名+字符串，值=“Calculation”，所得列名=“语文Calculation”
     * @return
     * @throws NoSuchFieldException
     * @throws IllegalAccessException
     */
    public static List<JSONObject> dataRow2ColData(List<Object> objDataList, String[] groupFields, String[] colsFields, String[] valueFields, String[] groupCalculationFun, String[] groupCalculationName) throws NoSuchFieldException, IllegalAccessException {
        return dataRow2ColData(objDataList, groupFields, colsFields, valueFields, groupCalculationFun, groupCalculationName, null);
    }

    /**
     * 行转列函数，拓展按权重的计算函数
     *
     * @param objDataList                          对象数据列表list
     * @param groupFields                          固定分组列
     * @param colsFields                           行转列动态列对应的属性字段，例如：科目字段（值是=语文 英语 数学）
     * @param valueFields                          行转列动态列对应的值字段，允许空：例如：成绩字段（值是=98.5 99 59.5）
     * @param groupCalculationFun                  聚合计算函数，支持[sum,count,max,min]不区分大小写
     * @param groupCalculationName                 计算值列名字符串=列名+字符串，值=“Calculation”，所得列名=“语文Calculation”
     * @param valueFieldsSumWeightCoefficientField 权重列名字符串，值=“WeightCoeff”，所得列名=“语文WeightCoeff”
     * @return
     * @throws NoSuchFieldException
     * @throws IllegalAccessException
     */
    public static List<JSONObject> dataRow2ColData(List<Object> objDataList, String[] groupFields, String[] colsFields, String[] valueFields, String[] groupCalculationFun, String[] groupCalculationName, String valueFieldsSumWeightCoefficientField) throws NoSuchFieldException, IllegalAccessException {
        List<JSONObject> resultJSONList = new ArrayList<JSONObject>();
        for (Object rowdata : objDataList) {
            JSONObject rowJSON = new JSONObject();
            boolean insetflag = false;
            for (String field : groupFields) {
                int list_i = getObjFromListIndex(rowdata, groupFields, resultJSONList, groupFields);

                //如果属性存在 且未处理过(不存在）
                if (isExistField(field, rowdata) && list_i == -1) {
                    Field objfield = rowdata.getClass().getDeclaredField(field);
                    //打开私有访问
                    objfield.setAccessible(true);
                    //获取属性值
                    String objfieldValue = String.valueOf(objfield.get(rowdata));
                    rowJSON.put(field, objfieldValue);
                    insetflag = true;
                }
            }
            //不重复的，应该记录数据
            if (insetflag) {
                resultJSONList.add(rowJSON);
            }
        }
        for (Object rowdata : objDataList) {
            int newColNum = 0;
            for (int i = 0; i < colsFields.length; i++) {
                int list_i = getObjFromListIndex(rowdata, groupFields, resultJSONList, groupFields);
                //如果属性存在，且在记录中，则添加字段
                if (isExistField(colsFields[i], rowdata) && list_i >= 0) {
                    JSONObject rowJSON = resultJSONList.get(list_i);
                    Field colnamefield = rowdata.getClass().getDeclaredField(colsFields[i]);
                    //打开私有访问
                    colnamefield.setAccessible(true);
                    //获取属性值
                    String colname = colnamefield.get(rowdata).toString();

                    Field colvaluefield = rowdata.getClass().getDeclaredField(valueFields[i]);
                    //打开私有访问
                    colvaluefield.setAccessible(true);
                    //获取属性值
                    String colvalue = colvaluefield.get(rowdata).toString();

                    //key=列名，例如：语文 英语
                    //value=数值，例如：98 69
                    rowJSON.put((String) colname, colvalue);
                    //权重系数
                    //key=列名，例如：语文WeightCoefficient 英语WeightCoefficient
                    //value=数值，例如：0.5 0.2
                    if (oConvertUtils.isNotEmpty(valueFieldsSumWeightCoefficientField)) {
                        Field sumWeightCoefficientfield = rowdata.getClass().getDeclaredField(valueFieldsSumWeightCoefficientField);
                        //打开私有访问
                        sumWeightCoefficientfield.setAccessible(true);
                        //获取属性值
                        String sumWeightCoefficientValue = sumWeightCoefficientfield.get(rowdata).toString();
                        rowJSON.put((String) colname + valueFieldsSumWeightCoefficientField, sumWeightCoefficientValue);
                    }

                    newColNum++; //新增列数加1


                }
            }


        }

        //重新循环一次，取最值
        for (JSONObject jo : resultJSONList) {
            if (oConvertUtils.isNotEmpty(groupCalculationFun) && oConvertUtils.isNotEmpty(groupCalculationName) && groupCalculationFun.length == groupCalculationName.length) {

                for (int i = 0; i < groupCalculationFun.length; i++) {
                    double calculationResult = 0.0;

                    int j = 0;
                    for (String key : jo.keySet()) {

                        //如果再固定列范围内，则不计算，否则计算（动态列部分进行计算）
                        if (Arrays.asList(groupFields).contains(key)) {
                            continue;
                        }
                        //如果在计算目标列表内，则不重复累加计算
                        if (Arrays.asList(groupCalculationName).contains(key)) {
                            continue;
                        }
                        //如果再权重列表内，则不计算
                        if (oConvertUtils.isNotEmpty(valueFieldsSumWeightCoefficientField) && key.equals(key.replace(valueFieldsSumWeightCoefficientField, "") + valueFieldsSumWeightCoefficientField)) {
                            //找一遍是否在权重范围内，在权重内则不计数
                            continue;
                        }

                        //获取属性值
                        double colvalue = Double.parseDouble(jo.get(key).toString());
                        if (groupCalculationFun[i].toUpperCase().equals("SUM")) {

                            //权重系数:加权求和
                            if (oConvertUtils.isNotEmpty(valueFieldsSumWeightCoefficientField)) {
                                calculationResult += colvalue * Double.parseDouble(jo.get(key + valueFieldsSumWeightCoefficientField).toString());
                            } else { //普通求和
                                calculationResult += colvalue;
                            }

                        } else if (groupCalculationFun[i].toUpperCase().equals("COUNT")) {
                            calculationResult += 1.0;
                        } else if (groupCalculationFun[i].toUpperCase().equals("MAX")) {
                            if (j == 0) {
                                calculationResult = colvalue;
                            } else {
                                calculationResult = calculationResult >= colvalue ? calculationResult : colvalue;
                            }
                        } else if (groupCalculationFun[i].toUpperCase().equals("MIN")) {
                            if (j == 0) {
                                calculationResult = colvalue;
                            } else {
                                calculationResult = calculationResult <= colvalue ? calculationResult : colvalue;
                            }
                        }

                        j++;
                    }
                    jo.put(groupCalculationName[i], calculationResult);
                }

            }
        }

        return resultJSONList;
    }

    /**
     * 查找对象在list中的索引位置
     * @param obj
     * @param objKeyFields
     * @param targetJSONList
     * @param jsonKeyFields
     * @return
     * @throws NoSuchFieldException
     * @throws IllegalAccessException
     */
    public static int getObjFromListIndex(Object obj, String[] objKeyFields, List<JSONObject> targetJSONList, String[] jsonKeyFields) throws NoSuchFieldException, IllegalAccessException {
        if (oConvertUtils.isEmpty(obj) || oConvertUtils.listIsEmpty(targetJSONList)) {
            return -1;
        }
        int findIndex = -1;
        for (int i = 0; i < targetJSONList.size(); i++) {
            boolean equalflag = true;
            for (int j = 0; j < objKeyFields.length; j++) {
                //如果属性存在
                if (isExistField(jsonKeyFields[j], targetJSONList.get(i))) {
//                Field  objfield = obj.getClass().getDeclaredField(keyfield);
//                //打开私有访问
//                objfield.setAccessible(true);
//                //获取属性值
//                String objfieldValue = oConvertUtils.isEmpty(objfield.get(obj)) ? null: objfield.get(obj).toString();
                    String objfieldValue = String.valueOf(getFieldValueByName(obj, objKeyFields[j]));

                    //判断是否相等，是否已存在
                    if (oConvertUtils.isEmpty(objfieldValue) || !objfieldValue.equals(targetJSONList.get(i).get(jsonKeyFields[j]))) {
                        //如果值不相等 ,则不相等
                        equalflag = false;
                        break;
                    }
                    //如果全相等，则返回索引值

                }
            }
            //如果已找到
            if (equalflag) {
//                return i;
                findIndex = i;
                break;
            }

        }
        return findIndex;
    }

    /**
     * 单纯的进行行转列：把一系列List<object>进行转列，无分组，无其他过程
     *
     * @param t
     * @param <T>
     * @return
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     */
    public static <T> Map<String, List<String>> RowColum(List<T> t) throws IllegalArgumentException, IllegalAccessException {
        Field[] fiedls = t.get(0).getClass().getDeclaredFields();
        Map<String, List<String>> maps = new HashMap<String, List<String>>();
        for (Field field : fiedls) {
            field.setAccessible(true);
            List<String> strs = new ArrayList<String>();
            for (T t1 : t) {
                strs.add(field.get(t1) == null ? null : field.get(t1).toString());
            }
            maps.put(field.getName(), strs);
        }
        return maps;
    }
    /** 获取对象的所有属性（包括父类）
     *
     */

    public static List<Field> getAllField(Class clazzT){
        //getSuperclass 可以获得上级父类的属性
        List<Field> allfileLists = new ArrayList<Field>();

        for (; clazzT != Object.class; clazzT = clazzT.getSuperclass()) {//向上循环 遍历父类
            Field[] allfields = clazzT.getDeclaredFields();
            for (Field field : allfields) {
                allfileLists.add(field);
            }
        }
        return allfileLists;
    }
    public static Field getFieldByName(Class clazzT,String fieldName){
        //getSuperclass 可以获得上级父类的属性
        List<Field> allfileLists = new ArrayList<Field>();

        for (; clazzT != Object.class; clazzT = clazzT.getSuperclass()) {//向上循环 遍历父类
            Field[] allfields = clazzT.getDeclaredFields();
            for (Field field : allfields) {
                if(fieldName.equals(field.getName())){
                    return field;
                }

            }
        }
        return null;
    }
    /** 获取对象的所有方法（包括父类）
     *
     */

    public static List<Method> getAllMethod(Class clazzT){
        //getSuperclass 可以获得上级父类的属性
        List<Method> allMethodLists = new ArrayList<Method>();

        for (; clazzT != Object.class; clazzT = clazzT.getSuperclass()) {//向上循环 遍历父类
            Method[] methods = clazzT.getDeclaredMethods();

            for (Method method : methods) {
                allMethodLists.add(method);
            }
        }
        return allMethodLists;
    }


    /**
     * 判断你一个类是否存在某个属性（字段）含继承的父类的属性（用JSON判断）
     *
     * @param field 字段
     * @param obj   类对象
     * @return true:存在，false:不存在, null:参数不合法
     */
    public static Boolean isExistField(String field, Object obj) {
        if (obj == null || oConvertUtils.isEmpty(field)) {
            return null;
        }
        Object o = JSON.toJSON(obj);
        JSONObject jsonObj = new JSONObject();
        if (o instanceof JSONObject) {
            jsonObj = (JSONObject) o;
        }

        return jsonObj.containsKey(field);
    }

    /**
     * 是否是本类的属性（不含父类属性）
     *
     * @param fieldName
     * @param clazz
     * @return
     * @throws NoSuchFieldException
     */
    public static Boolean isExistFieldNameNoIncludeFather(String fieldName, Class clazz) throws NoSuchFieldException {
        boolean flag = false;
        // 取得本类的全部属性
        Field[] fields = clazz.getDeclaredFields();

        //循环遍历所有的fields

        for (int i = 0; i < fields.length; i++) {
            if (fields[i].getName().equals(fieldName)) {
                flag = true;
                break;
            }
        }
        return flag;
    }

    /**
     * 是否是本类的属性（含父类属性）
     *
     * @param fieldName
     * @param clazz
     * @return
     * @throws NoSuchFieldException
     */
    public static Boolean isExistFieldNameIncludeFather(String fieldName, Class clazz){

        //getSuperclass 可以获得上级父类的属性
        Class clazzT = clazz;
        for (; clazzT != Object.class; clazzT = clazzT.getSuperclass()) {//向上循环 遍历父类
            Field[] allfields = clazzT.getDeclaredFields();
            for (Field field : allfields) {
                if (field.getName().equals(fieldName)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 返回属性名对应的对象的值
     *
     * @param obj
     * @param fieldName
     * @return
     * @throws NoSuchFieldException
     * @throws IllegalAccessException
     */
    public static Object getFieldValueByNameFromObj(Object obj, String fieldName) throws NoSuchFieldException, IllegalAccessException {
        if (isExistField(fieldName, obj)) {
//            return getFieldValueByName(obj,fieldName);
            // getDeclaredField 只能得到对象自身属性，不能得到继承自父类的属性
//            Field colnamefield = obj.getClass().getDeclaredField(fieldName);
//            //打开私有访问
//            colnamefield.setAccessible(true);
//            //获取属性值
//            return colnamefield.get(obj);

            //getSuperclass 可以获得上级父类的属性
            Class clazz = obj.getClass();
            for (; clazz != Object.class; clazz = clazz.getSuperclass()) {//向上循环 遍历父类
                Field[] allfields = clazz.getDeclaredFields();
                for (Field field : allfields) {
                    if (field.getName().equals(fieldName)) {
                        field.setAccessible(true);
                        return field.get(obj);
                    }
                }
            }

        } else {
            return null;
        }
        return null;
    }

    /**
     * 获取对象指定属性的值
     *
     * @param o         对象
     * @param fieldName 要获取值的属性
     *                  返回值：对象指定属性的值
     */
    public static Object getFieldValueByName(Object o, String fieldName) {
        try {
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + firstLetter + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[]{});
            Object value = method.invoke(o, new Object[]{});
            return value;
        } catch (Exception e) {
            System.out.println(e.getMessage());
            return null;
        }
    }
    /**
     * 根据名称给对象赋值，调用set方法实现
     *
     * @param o         对象
     * @param fieldName 要获取值的属性
     *                  返回值：对象指定属性的值
     */
    public static Object setFieldValueByName(Object o, String fieldName,Object value) {
        try {
            //如果属性存在
            if(isExistFieldNameIncludeFather(fieldName,o.getClass())) {
                Field field = getFieldByName(o.getClass(),fieldName);
                Class typeClass = field.getType();
                return setFieldValueByName(o,field,value);

//                String firstLetter = fieldName.substring(0, 1).toUpperCase();
//                String setter = "set" + firstLetter + fieldName.substring(1);
////            Method method = o.getClass().getMethod(setter, new Class[]{});
////            method.invoke(o, new Object[]{value});
//                Method method = o.getClass().getDeclaredMethod(setter, new Class[]{typeClass});
//                if (null == value) {
//                    method.invoke(o, new Object[]{null});
//                } else {
//                    method.invoke(o, new Object[]{getClassTypeValue(typeClass, value)});
//                }
            }
            return o;
        } catch (Exception e) {
            System.out.println("根据名称给对象赋值，调用set方法出错"+e.getMessage());
            return null;
        }
    }

    /**

     * 判断是否存在某属性的 set方法

     * @param methods

     * @param fieldSetMet

     * @return boolean

     */

    public static boolean checkSetMet(List<Method> methods, String fieldSetMet) {
        for (Method met : methods) {
            if (fieldSetMet.equals(met.getName())) {
                return true;
            }
        }
        return false;
    }



    /**

     * 判断是否存在某属性的 get方法

     * @param methods

     * @param fieldGetMet

     * @return boolean

     */

    public static boolean checkGetMet(Method[] methods, String fieldGetMet) {

        for (Method met : methods) {

            if (fieldGetMet.equals(met.getName())) {

                return true;

            }

        }

        return false;

    }



    /**

     * 拼接某属性的 get方法

     * @param fieldName

     * @return String

     */

    public static String parGetName(String fieldName) {

        if (null == fieldName || "".equals(fieldName)) {

            return null;

        }

        return "get" + fieldName.substring(0, 1).toUpperCase()

                + fieldName.substring(1);

    }
    /**

     * 拼接在某属性的 set方法

     * @param fieldName

     * @return String

     */

    public static String parSetName(String fieldName) {
        if (null == fieldName || "".equals(fieldName)) {
            return null;
        }
        return "set" + fieldName.substring(0, 1).toUpperCase()
                + fieldName.substring(1);
    }

    /**

     * 格式化string为Date

     * @param datestr

     * @return date

     */

    public static Date parseDate(String datestr) {

        if (null == datestr || "".equals(datestr)) {

            return null;

        }

        try {

            String fmtstr = null;

            if (datestr.indexOf(':') > 0) {

                fmtstr = "yyyy-MM-dd HH:mm:ss";

            } else {



                fmtstr = "yyyy-MM-dd";

            }

            SimpleDateFormat sdf = new SimpleDateFormat(fmtstr, Locale.UK);

            return sdf.parse(datestr);

        } catch (Exception e) {

            return null;

        }

    }



    /**

     * 日期转化为String

     * @param date

     * @return date string

     */

    public static String fmtDate(Date date) {

        if (null == date) {

            return null;

        }

        try {

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss",

                    Locale.US);

            return sdf.format(date);

        } catch (Exception e) {

            return null;

        }

    }
    /**

     * 取Bean的属性和值对应关系的MAP

     * @param bean

     * @return Map

     */

    public static Map<String, String> getFieldValueMap(Object bean) {
        Class<?> cls = bean.getClass();
        Map<String, String> valueMap = new HashMap<String, String>();
// 取出bean里的所有方法
        Method[] methods = cls.getDeclaredMethods();
        Field[] fields = cls.getDeclaredFields();
        for (Field field : fields) {
            try {
                String fieldType = field.getType().getSimpleName();
                String fieldGetName = parGetName(field.getName());
                if (!checkGetMet(methods, fieldGetName)) {
                    continue;
                }
                Method fieldGetMet = cls.getMethod(fieldGetName, new Class[] {});
                Object fieldVal = fieldGetMet.invoke(bean, new Object[] {});
                String result = null;
                if ("Date".equals(fieldType)) {
                    result = fmtDate((Date) fieldVal);

                } else {
                    if (null != fieldVal) {
                        result = String.valueOf(fieldVal);
                    }
                }
                valueMap.put(field.getName(), result);
            } catch (Exception e) {
                continue;
            }
        }
        return valueMap;
    }

    /**
     * 给对象指定的属性设置值,通过反射调用set方法设置
     *
     * @param bean       要设置值的对象
     * @param field 要设置值的属性
     * @param valued     值
     */
    public static boolean setFieldValueByName(Object bean, Field field, Object valued) {
//        try {
//            // 获取obj类的字节文件对象
//            Class c = obj.getClass();
//            // 取出bean里的所有方法
//            Method[] methods = c.getDeclaredMethods();
//            // 获取该类的成员变量
//            Field f = c.getDeclaredField(fieldName);
//            // 取消语言访问检查
//            f.setAccessible(true);
//            // 给变量赋值
//            f.set(obj, value);
//
//        } catch (Exception e) {
//            System.out.println(e.getMessage());
//        }
        try {
            // 获取obj类的字节文件对象
            Class clazz = bean.getClass();
            // 取出bean里的所有方法
            List<Method> methods = getAllMethod(clazz);

            String fieldSetName = parSetName(field.getName());

            if (!checkSetMet(methods, fieldSetName)) {

                return false;

            }

            Method fieldSetMet = clazz.getMethod(fieldSetName, field.getType());



            if (null != valued ) {
                String value = valued.toString();

                String fieldType = field.getType().getSimpleName();

                if ("String".equals(fieldType)) {

                    fieldSetMet.invoke(bean, new String[]{value});

                } else if ("Date".equals(fieldType)) {

                    Date temp = parseDate(value);

                    fieldSetMet.invoke(bean, new Date[]{temp});

                } else if ("Integer".equals(fieldType)

                        || "int".equals(fieldType)) {

                    Integer intval = Integer.parseInt(value);

                    fieldSetMet.invoke(bean, new int[]{intval});

                } else if ("Long".equalsIgnoreCase(fieldType)) {

                    Long temp = Long.parseLong(value);

                    fieldSetMet.invoke(bean, new Long[]{temp});

                } else if ("Double".equalsIgnoreCase(fieldType)) {

                    Double temp = Double.parseDouble(value);

                    fieldSetMet.invoke(bean, new Double[]{temp});

                } else if ("Boolean".equalsIgnoreCase(fieldType)) {

                    Boolean temp = Boolean.parseBoolean(value);

                    fieldSetMet.invoke(bean, new Boolean[]{temp});

                } else {

                    System.out.println("not supper type" + fieldType);

                }

            }
            else{
                fieldSetMet.invoke(bean, new Object[]{null});
            }

        } catch (Exception e) {
            System.out.println("根据名称给对象赋值，调用set方法出错:"+e.getMessage());
            return false;

        }
        return  true;
    }

    /**
     * 深度复制克隆对象的属性
     * @param source
     * @param target
     */
    public static void copyDeepCloneProperties(Object source, Object target){
        //source先转换为map，再转换为target,把2合并到1上，最后将是以2为准
        Map targetMap = merageMap(MapBeanUtils.bean2Map(source),MapBeanUtils.bean2Map(target)) ;
        //先合并两个对象的所有属性，以第2个target为准，然后再转为bean
        MapBeanUtils.map2BeanObj(target,targetMap);
    }
    /**
     * 深度批量复制克隆对象的属性
     * @param sourceObjList
     * @param clazz
     */
    public static List<T> copyDeepClonePropertiesByObjList(List<Object> sourceObjList, Class<T> clazz) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        List<T> targetObjList = new ArrayList<T>();
        for(int i=0;i< sourceObjList.size() ;i++) {
            T res = clazz.getDeclaredConstructor().newInstance();
            copyDeepCloneProperties(sourceObjList.get(i),res);
            targetObjList.add(res);
        }
        return targetObjList;
    }

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        List<Object> stulist = new ArrayList<Object>();
        StuStudent stu1 = new StuStudent();
        stu1.setStudentFromSchool("一中");
        stu1.setStudentHeight(170.0);
        stu1.setStudentName("张三");
        stu1.setStudentNo("0.5");


        StuStudent stu2 = new StuStudent();
        stu2.setStudentFromSchool("一中");
        stu2.setStudentHeight(172.0);
        stu2.setStudentName("李四");
        stu2.setStudentNo("0.3");


        StuStudent stu3 = new StuStudent();
        stu3.setStudentFromSchool("二中");
        stu3.setStudentHeight(160.0);
        stu3.setStudentName("张三");
        stu3.setStudentNo("0.5");


        StuStudent stu4 = new StuStudent();
        stu4.setStudentFromSchool("二中");
        stu4.setStudentHeight(162.0);
        stu4.setStudentName("李四");
        stu4.setStudentNo("0.5");


        stulist.add(stu1);
        stulist.add(stu2);
        stulist.add(stu3);
        stulist.add(stu4);

        String[] groupField = new String[]{"studentFromSchool"}; //new String[](["studentFromSchool"]);
        String[] colsField = new String[]{"studentName"};
        String[] valueField = new String[]{"studentHeight"};
        String[] groupCalFun = new String[]{"MAx", "Min", "sum", "couNt"};
        String[] groupCalName = new String[]{"maxvalue", "minvalue", "sumvalue", "countvalue"};
        String weithg = "studentNo";
        List<JSONObject> JSONList = dataRow2ColData(stulist, groupField, colsField, valueField, groupCalFun, groupCalName, weithg);

//        Row2ColUtil<StuStudent> r = new Row2ColUtil<StuStudent>( groupField, colsField, valueField,groupCalFun,groupCalName,weithg);
//
//        List<JSONObject> JSONList = r.Row2Col(stulist);
        System.out.println(JSONList.toString());

//        System.out.println(isExistField("studentName",stu));
//        System.out.println(isExistField("studentName",StuStudent.class));
    }

    /**
     * @param clzz
     * @param methodName
     * @param argsType
     * @return boolean
     * @Description: 判断类中是否包含某个方法
     * @version v1.0
     * @author wu
     * @date 2022年5月2日 下午11:03:56
     * @see org.springframework.util.ReflectionUtils
     */
    public static boolean hasMethod(Class clzz, String methodName, Class[] argsType) {
        Method method = ReflectionUtils.findMethod(clzz, methodName, argsType);
        if (null != method) {
            return true;
        }
        return false;
    }

    /**
     * @param clzz
     * @param fieldName
     * @return boolean
     * @Description: 判断类中是否包含某个字段
     * @version v1.0
     * @author wu
     * @date 2022年5月2日 下午11:03:34
     * @see org.springframework.util.ReflectionUtils
     */
    public static boolean hasField(Class clzz, String fieldName) {
        Field field = ReflectionUtils.findField(clzz, fieldName);
        if (field != null) {
            return true;
        }
        return false;
    }

    /**
     * 合并map对象
     */
    public static Map merageMap(Map source1, Map source2) {
        if (source1 == null && source2 != null) {
            source1 = source2;
        }
        if (source2 != null) {
            Set map2 = source2.keySet();
            Iterator item = map2.iterator();
            while (item.hasNext()) {
                String key = (String)item.next();
                source1.put(key, source2.get(key));
            }
        }
        return source1;
    }
    /**
     * 通过class类型获取获取对应类型的值
     * @param typeClass class类型
     * @param value 值
     * @return Object
     */
    private static Object getClassTypeValue(Class<?> typeClass, Object value){
        if(typeClass == int.class  || value instanceof Integer){
            if(null == value){
                return 0;
            }
            return value;
        }else if(typeClass == short.class){
            if(null == value){
                return 0;
            }
            return value;
        }else if(typeClass == byte.class){
            if(null == value){
                return 0;
            }
            return value;
        }else if(typeClass == double.class){
            if(null == value){
                return 0;
            }
            return value;
        }else if(typeClass == long.class){
            if(null == value){
                return 0;
            }
            return value;
        }else if(typeClass == String.class){
            if(null == value){
                return "";
            }
            return value;
        }else if(typeClass == boolean.class){
            if(null == value){
                return true;
            }
            return value;
        }else if(typeClass == BigDecimal.class){
            if(null == value){
                return new BigDecimal(0);
            }
            return new BigDecimal(value+"");
        }else {
            return typeClass.cast(value);
        }
    }
}
